home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
World of Video
/
World of Video.iso
/
gfxprograms
/
3dprograms
/
t3dlib
/
source
/
readtddd.c
< prev
next >
Wrap
C/C++ Source or Header
|
1995-02-13
|
41KB
|
1,434 lines
/* ReadTDDD.c - read a TDDD (Three Dimension Data Decription) file
* - written by Glenn M. Lewis - 9/4/91
*/
static char rcs_id[] = "$Id: readtddd.c,v 1.31 1993/12/11 22:22:19 glewis Exp $";
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include "t3dlib.h"
#ifdef __STDC__
#include <stdlib.h>
#include <strings.h>
#include "readtddd_protos.h"
#endif
#define MAXLINE 132
#ifndef PI
#define PI (3.14159265)
#endif
int verbose_flag=0;
static void process_DESC();
static OBJECT *process_EXTR();
static void process_INFO();
static void process_OBJ();
void insert_into_sorted_list();
/* Here are a few necessary utilities */
static void get_name(name, size, world)
register char *name;
register int size;
WORLD *world;
{
while (size--) *name++ = fgetc(world->inp);
*name = '\0';
}
static BYTE get_BYTE(world)
WORLD *world;
{
return((BYTE)fgetc(world->inp));
}
static UBYTE get_UBYTE(world)
WORLD *world;
{
return((UBYTE)fgetc(world->inp));
}
static WORD get_WORD(world)
WORLD *world;
{
WORD tmp = (WORD)get_UBYTE(world)<<8;
return((WORD)(tmp|get_UBYTE(world)));
}
static UWORD get_UWORD(world)
WORLD *world;
{
UWORD tmp = (UWORD)get_UBYTE(world)<<8;
return((UWORD)(tmp|get_UBYTE(world)));
}
static ULONG get_ULONG(world)
WORLD *world;
{
ULONG tmp = (ULONG)get_UWORD(world)<<16;
return(tmp|get_UWORD(world));
}
static double get_FRACT(world) /* This sets the precision to 10^(-3) */
WORLD *world;
{
register double whole, fract;
whole = (double)get_WORD(world);
fract = ((double)get_UWORD(world))/(double)65536.0;
return((double)(whole+fract));
}
static void stuff_XYZ(st, world)
XYZ_st *st;
WORLD *world;
{
st->x = get_FRACT(world);
st->y = get_FRACT(world);
st->z = get_FRACT(world);
}
static void stuff_RGB(st, world)
RGB_st *st;
WORLD *world;
{
get_UBYTE(world); /* pad byte */
st->r = get_UBYTE(world);
st->g = get_UBYTE(world);
st->b = get_UBYTE(world);
}
static void output_warning(world, area, name, size)
WORLD *world;
char *area, *name;
ULONG size;
{
ULONG i;
int j;
unsigned char tmpstr[20];
fprintf(stderr, "WARNING: Unknown %ssub-chunk: '%s', size %lu...\n",
area, name, size);
for (i=0; i<size; i+=16) {
fprintf(stderr, "%04lx:", i);
for (j=0; j<16 && i+j<size; j++)
fprintf(stderr, " %02x", tmpstr[j] = (fgetc(world->inp)&0xff));
while (j++ < 16) fputs(" ", stderr);
fputs(" ", stderr);
/* Print out the ASCII equivalent */
for (j=0; j<16 && i+j<size; j++) {
tmpstr[j] &= 0x7F; /* Strip off upper bit */
if (isprint(tmpstr[j]))
fputc(tmpstr[j], stderr);
else fputc('.', stderr);
}
fputs("\n", stderr);
}
}
/********************/
/* The MAIN section */
/********************/
int already_read_header = 0;
unsigned char header_storage[13];
WORLD *read_World(file)
FILE *file;
{
int i;
for (i=0; i<4; i++) header_storage[i] = fgetc(file);
already_read_header = 4;
if (strncmp(header_storage, "FORM", 4)==0) {
while (i<12) header_storage[i++] = fgetc(file);
already_read_header = 12;
if (strncmp(&header_storage[8], "TDDD", 4)==0) return(read_TDDD(file));
#if 0
if (strncmp(&header_storage[8], "LWOB", 4)==0) return(read_LWOB(file));
#endif
if (strncmp(&header_storage[8], "ISTG", 4)==0) return(read_ISTG(file));
/* BAD IFF */
header_storage[12] = 0;
fprintf(stderr, "ERROR! Unknown FORM: '%s'\n", &header_storage[8]);
return(0);
} else {
return(read_TTDDD(file));
}
}
WORLD *read_TDDD(file)
FILE *file;
{
register ULONG i, len, size;
WORLD *world;
char name[5];
if (!file) return(0L); /* File not open */
if (!(world = (WORLD*)malloc(sizeof(WORLD)))) { OUT_MEM("WORLD"); }
bzero((char*)world, sizeof(WORLD));
world->inp = file;
if (!already_read_header) {
/* Parse the IFF TDDD file */
get_name(name, 4, world);
if (strcmp(name, "FORM") != 0) {
fprintf(stderr, "ERROR: Input is not an IFF file.\n"); exit(-1); }
if (!(len = get_ULONG(world))) {
fprintf(stderr, "ERROR: Bad FORM length in IFF file.\n"); exit(-1); }
get_name(name, 4, world);
if (strcmp(name, "TDDD") != 0) {
fprintf(stderr, "ERROR: IFF file is not a TDDD file.\n"); exit(-1); }
} else {
len = (header_storage[4]<<24) | (header_storage[5]<<16) |
(header_storage[6]<< 8) | (header_storage[7] );
already_read_header = 0;
}
len -= 4;
/* Here is the main loop: */
while (len>0) {
get_name(name, 4, world);
size = get_ULONG(world);
len -= 8;
if (strcmp(name, "INFO")==0) process_INFO(size, world);
else
if (strcmp(name, "OBJ ")==0) process_OBJ(size, world);
else {
if (verbose_flag) output_warning(world, "", name, size);
else {
for (i=size; i--; ) fgetc(world->inp); /* Skip this section */
}
}
if (size&1) { fgetc(world->inp); len--; } /* Skip odd byte */
len -= size;
}
/* All done. */
return(world);
}
static void process_INFO(len, world)
register ULONG len;
WORLD *world;
{
register INFO *info;
register ULONG i, size;
char name[5];
if (world->info) {
fputs("ERROR: More than one INFO chunk!\n", stderr); exit(-1); }
if (!(info = world->info = (INFO*)malloc(sizeof(INFO)))) { OUT_MEM("INFO"); }
bzero((char*)world->info, sizeof(INFO));
if (verbose_flag>1) fprintf(stderr, "INFO chunk.\n");
while (len>0) {
get_name(name, 4, world);
size = get_ULONG(world);
len -= 8;
if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
if (strcmp(name, "BRSH")==0) {
i = get_UWORD(world);
if (i<0 || i>7) { i=0; fputs("BRSH error.\n", stderr); }
get_name(info->brsh[i], 80, world);
} else
if (strcmp(name, "STNC")==0) {
i = get_UWORD(world);
if (i<0 || i>7) { i=0; fputs("STNC error.\n", stderr); }
get_name(info->stnc[i], 80, world);
} else
if (strcmp(name, "TXTR")==0) {
i = get_UWORD(world);
if (i<0 || i>7) { i=0; fputs("TXTR error.\n", stderr); }
get_name(info->txtr[i], 80, world);
} else
if (strcmp(name, "OBSV")==0) {
if (!info->obsv) info->obsv=(OBSV*)malloc(sizeof(OBSV));
if (!info->obsv) { OUT_MEM("OBSV"); }
stuff_XYZ(&info->obsv->came, world);
stuff_XYZ(&info->obsv->rota, world);
info->obsv->foca = get_FRACT(world);
} else
if (strcmp(name, "OTRK")==0) {
get_name(info->otrk, 18, world);
} else
if (strcmp(name, "OSTR")==0) {
if (!info->ostr) info->ostr=(STRY*)malloc(sizeof(STRY));
if (!info->ostr) { OUT_MEM("OSTR"); }
get_name(info->ostr->path, 18, world);
stuff_XYZ(&info->ostr->tran, world);
stuff_XYZ(&info->ostr->rota, world);
stuff_XYZ(&info->ostr->scal, world);
info->ostr->info = get_UWORD(world);
} else
if (strcmp(name, "FADE")==0) {
if (!info->fade) info->fade=(FADE*)malloc(sizeof(FADE));
if (!info->fade) { OUT_MEM("FADE"); }
info->fade->at = get_FRACT(world);
info->fade->by = get_FRACT(world);
stuff_RGB(&info->fade->to, world);
} else
if (strcmp(name, "SKYC")==0) {
if (!info->skyc) info->skyc=(SKYC*)malloc(sizeof(SKYC));
if (!info->skyc) { OUT_MEM("SKYC"); }
stuff_RGB(&info->skyc->hori, world);
stuff_RGB(&info->skyc->zeni, world);
} else
if (strcmp(name, "AMBI")==0) {
if (!info->ambi) info->ambi=(RGB_st*)malloc(sizeof(RGB_st));
if (!info->ambi) { OUT_MEM("AMBI"); }
stuff_RGB(info->ambi, world);
} else
if (strcmp(name, "GLB0")==0) {
if (!info->glb0) info->glb0=(BYTE*)malloc(8*sizeof(BYTE));
if (!info->glb0) { OUT_MEM("GLB0"); }
for (i=0; i<8; i++)
info->glb0[i] = get_UBYTE(world);
} else {
if (verbose_flag) output_warning(world, "INFO ", name, size);
else {
for (i=size; i--; ) fgetc(world->inp); /* Skip this section */
}
}
if (size&1) { fgetc(world->inp); len--; } /* Skip odd byte */
len -= size;
}
}
static void process_OBJ(len, world)
register ULONG len;
WORLD *world;
{
register ULONG i, size;
register OBJECT *p;
char name[5];
int depth=0;
if (verbose_flag>1) fprintf(stderr, "OBJ chunk.\n");
while (len>0) {
get_name(name, 4, world);
size = get_ULONG(world);
len -= 8;
if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
if (strcmp(name, "EXTR")==0) {
p = process_EXTR(size, create_object(), world);
if (world->curobj) {
world->curobj->next = p;
p->parent = world->curobj->parent;
} else {
world->object = p;
p->parent = 0;
}
world->curobj = p;
} else if (strcmp(name, "DESC")==0) {
p = create_object();
if (world->num_DESC > world->num_TOBJ+depth) { /* This is a child */
depth++; /* Down one in the hierarchy */
world->curobj->child = p;
p->parent = world->curobj;
} else {
if (world->curobj) {
world->curobj->next = p;
p->parent = world->curobj->parent;
} else {
world->object = p;
p->parent = 0;
}
}
world->curobj = p;
process_DESC(size, &p->desc, world);
} else if (strcmp(name, "TOBJ")==0) {
world->num_TOBJ++;
if (world->num_TOBJ > world->num_DESC) {
fprintf(stderr, "Warning: TOBJ without DESC. Ignored.\n");
}
if (world->num_TOBJ+depth > world->num_DESC) { /* Up a level */
depth--;
world->curobj=world->curobj->parent;
}
} else {
if (verbose_flag) output_warning(world, "OBJ ", name, size);
else {
for (i=size; i--; ) fgetc(world->inp); /* Skip this section */
}
}
if (size&1) { fgetc(world->inp); len--; } /* Skip odd byte */
len -= size;
}
}
OBJECT *load_external_object(filename, mtrx)
char *filename;
MTRX *mtrx;
{
WORLD *new;
FILE *newinp;
register OBJECT *p;
/* Now, load in the external object */
TRY_EXTR_AGAIN:
if (!(newinp=fopen(filename, "r"))) {
fprintf(stderr, "Can't load in EXTR object: '%s'.\n",
filename);
fprintf(stderr, "Enter filneame (or CR to abort): "); fflush(stderr);
fgets(filename, 512, stdin);
if (!filename[0] || filename[0]=='\n') return(0L);
goto TRY_EXTR_AGAIN;
}
new = read_World(newinp);
fclose(newinp);
/* scale, rotate, and translate new object hierarchy */
for (p=new->object; p; p=p->next)
move_extr(p, mtrx);
p = new->object;
free((char*)new);
return(p);
}
static OBJECT *process_EXTR(len, obj, world)
register ULONG len;
OBJECT *obj;
WORLD *world;
{
register ULONG i, size;
register EXTR *extr;
char name[5];
MTRX *mtrx;
if (!(extr = obj->extr = (EXTR*)malloc(sizeof(EXTR))))
{ OUT_MEM("EXTR"); }
bzero((char*)extr, sizeof(EXTR));
mtrx = &extr->mtrx;
/* Initialize structure */
mtrx->tran.x = mtrx->tran.y = mtrx->tran.z = 0.0;
mtrx->scal.x = mtrx->scal.y = mtrx->scal.z = 1.0;
mtrx->rota1.y = mtrx->rota1.z = 0.0;
mtrx->rota2.x = mtrx->rota2.z = 0.0;
mtrx->rota3.x = mtrx->rota3.y = 0.0;
mtrx->rota1.x = mtrx->rota2.y = mtrx->rota3.z = 1.0;
if (verbose_flag>1) fprintf(stderr, "EXTR chunk.\n");
while (len>0) {
get_name(name, 4, world);
size = get_ULONG(world);
len -= 8;
if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
if (strcmp(name, "MTRX")==0) {
stuff_XYZ(&mtrx->tran, world);
stuff_XYZ(&mtrx->scal, world);
stuff_XYZ(&mtrx->rota1, world);
stuff_XYZ(&mtrx->rota2, world);
stuff_XYZ(&mtrx->rota3, world);
} else
if (strcmp(name, "LOAD")==0) {
get_name(extr->filename, 80, world);
} else {
if (verbose_flag) output_warning(world, "EXTR ", name, size);
else {
for (i=size; i--; ) fgetc(world->inp); /* Skip this section */
}
}
if (size&1) { fgetc(world->inp); len--; } /* Skip odd byte */
len -= size;
}
/* Free up unused memory */
free((char*)obj->extr);
free((char*)obj);
obj = load_external_object(extr->filename, mtrx);
return(obj);
}
static UBYTE defclst[3], defrlst[3], deftlst[3], defspc1[3];
static void malloc_arrays(i, desc)
register int i;
register DESC *desc;
{
if (!desc->fcount) {
desc->fcount = i;
if (!(desc->face=(UWORD*)malloc(3*desc->fcount*sizeof(UWORD))))OUT_MEM((char*)0);
if (!(desc->clst=(UBYTE*)malloc(3*desc->fcount*sizeof(UBYTE))))OUT_MEM((char*)0);
if (!(desc->rlst=(UBYTE*)malloc(3*desc->fcount*sizeof(UBYTE))))OUT_MEM((char*)0);
if (!(desc->tlst=(UBYTE*)malloc(3*desc->fcount*sizeof(UBYTE))))OUT_MEM((char*)0);
/* Initialize arrays */
for (i=0; i<3*desc->fcount; i+=3) {
desc->face[i] = desc->face[i+1] = desc->face[i+2] = 0;
desc->clst[i] = defclst[0];
desc->clst[i+1] = defclst[1];
desc->clst[i+2] = defclst[2];
desc->rlst[i] = defrlst[0];
desc->rlst[i+1] = defrlst[1];
desc->rlst[i+2] = defrlst[2];
desc->tlst[i] = deftlst[0];
desc->tlst[i+1] = deftlst[1];
desc->tlst[i+2] = deftlst[2];
}
} else if (i != desc->fcount) {
fprintf(stderr, "ERROR: FACE and [C|R|T]LST 'Count' values inconsistant.\n");
OUT_MEM((char*)0);
}
}
static void process_DESC(len, orig, world)
register ULONG len;
DESC **orig;
WORLD *world;
{
register ULONG size;
register DESC *desc;
register int i, j;
FGRP *fgrp;
char name[5];
ULONG ccsize;
if (!(desc = *orig = (DESC*)malloc(sizeof(DESC))))
{ OUT_MEM("DESC"); }
bzero((char*)desc, sizeof(DESC));
/* Set up defaults: */
defclst[0] = defclst[1] = defclst[2] = 240; /* TS default */
defrlst[0] = defrlst[1] = defrlst[2] = 0;
deftlst[0] = deftlst[1] = deftlst[2] = 0;
defspc1[0] = defspc1[1] = defspc1[2] = 0;
world->num_DESC++;
if (verbose_flag>1) fprintf(stderr, "DESC chunk.\n");
while (len>0) {
get_name(name, 4, world);
size = get_ULONG(world);
len -= 8;
if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
if (strcmp(name, "NAME")==0) {
get_name(desc->name, 18, world);
} else
if (strcmp(name, "SHAP")==0) {
if (!desc->shap) {
if (!(desc->shap=(WORD*)malloc(2*sizeof(WORD))))
{ OUT_MEM("SHAP"); }
desc->shap[0] = 2; /* TS defaults */
desc->shap[1] = 0;
}
desc->shap[0] = get_UWORD(world);
desc->shap[1] = get_UWORD(world);
} else
if (strcmp(name, "POSI")==0) {
if (!desc->posi) {
if (!(desc->posi=(XYZ_st*)malloc(sizeof(XYZ_st))))
{ OUT_MEM("POSI"); }
}
stuff_XYZ(desc->posi, world);
} else
if (strcmp(name, "AXIS")==0) {
if (!desc->axis) {
if (!(desc->axis=(AXIS*)malloc(sizeof(AXIS))))
{ OUT_MEM("AXIS"); }
bzero((char*)desc->axis, sizeof(AXIS));
desc->axis->xaxi.x = 1;
desc->axis->yaxi.y = 1;
desc->axis->zaxi.z = 1;
}
stuff_XYZ(&desc->axis->xaxi, world);
stuff_XYZ(&desc->axis->yaxi, world);
stuff_XYZ(&desc->axis->zaxi, world);
} else
if (strcmp(name, "SIZE")==0) {
if (!desc->size) {
if (!(desc->size=(XYZ_st*)malloc(sizeof(XYZ_st))))
{ OUT_MEM("SIZE"); }
}
stuff_XYZ(desc->size, world);
} else
if (strcmp(name, "PNTS")==0) {
i = desc->pcount = get_UWORD(world); /* Number of points */
if (!(desc->pnts = (XYZ_st*)malloc(desc->pcount*sizeof(XYZ_st))))
OUT_MEM("PNTS");
for (j=0; j<i; j++)
{ stuff_XYZ(&desc->pnts[j], world); }
} else
if (strcmp(name, "EDGE")==0) {
i = desc->ecount = get_UWORD(world); /* Number of edges */
if (!(desc->edge = (UWORD*)malloc(2*desc->ecount*sizeof(UWORD))))
OUT_MEM("EDGE");
for (j=0; j<2*i; j++)
{ desc->edge[j] = get_UWORD(world); }
} else
if (strcmp(name, "EFLG")==0) { /* An undocumented chunk */
if (!(desc->eflg = (EFLG*)malloc(sizeof(EFLG))))
OUT_MEM("EFLG");
i = desc->eflg->num = get_UWORD(world); /* Number of edge flags */
if (!(desc->eflg->eflg=(UBYTE*)malloc(desc->eflg->num*sizeof(UBYTE))))
OUT_MEM("EFLG");
for (j=0; j<i; j++)
{ desc->eflg->eflg[j] = get_UBYTE(world); }
} else
if (strcmp(name, "FACE")==0) {
i = get_UWORD(world); /* Number of faces */
malloc_arrays(i, desc);
for (j=0; j<i; j++) {
desc->face[3*j] = get_UWORD(world);
desc->face[3*j+1] = get_UWORD(world);
desc->face[3*j+2] = get_UWORD(world);
}
} else
if (strcmp(name, "TXT2")==0) {
for (i=0; i<4 && desc->txt2[i]; i++) ;
if (i==4) { /* ERROR! */
fprintf(stderr, "WARNING! More than 4 TXT2 chunks!\n");
i--;
}
if (!(desc->txt2[i] = (TXT2*)malloc(sizeof(TXT2)))) OUT_MEM("TXT2");
desc->txt2[i]->Flags = get_UWORD(world);
ccsize = 2;
stuff_XYZ(&desc->txt2[i]->TAxis.tran, world);
stuff_XYZ(&desc->txt2[i]->TAxis.rota1, world);
stuff_XYZ(&desc->txt2[i]->TAxis.rota2, world);
stuff_XYZ(&desc->txt2[i]->TAxis.rota3, world);
stuff_XYZ(&desc->txt2[i]->TAxis.scal, world);
ccsize = ccsize + 60;
for (j = 0; j < 16; j++) desc->txt2[i]->Params[j] = get_FRACT(world);
ccsize = ccsize + 64;
for (j = 0; j < 16; j++) desc->txt2[i]->PFlags[j] = get_UBYTE(world);
ccsize = ccsize + 16;
ccsize = ccsize + 17;
get_name(desc->txt2[i]->SubName, 17, world);
j = get_UWORD(world);
ccsize = ccsize + 2 + j;
desc->txt2[i]->Length = j;
get_name(desc->txt2[i]->Name, j, world);
for (j=ccsize; j < size; j++) get_UBYTE(world);
} else
#if 0
if (strcmp(name, "FOR2")==0) { /* Another undocumented chunk */
newsize = size;
i = get_UWORD(world); /* NumC */
newsize -= 2;
NumC = i;
fprintf(stderr, "Encountered 'FOR2' chunk...size=%lu\n NumC=%u\n", size, i);
i = get_UWORD(world); /* NumF */
newsize -= 2;
NumF = i;
fprintf(stderr, " NumF=%u\n", i);
i = get_UWORD(world); /* Flags */
newsize -= 2;
fprintf(stderr, " Flags=%u\n", i);
i = get_UWORD(world); /* pad */
newsize -= 2;
fprintf(stderr, " pad=%u\n", i);
for (j=0; j<9; j++) fprintf(stderr, " MTRX[%d]=%.12g\n", j, get_FRACT(world));
newsize -= 36;
fprintf(stderr, " ShiftX=%.12g ", get_FRACT(world));
fprintf(stderr, "ShiftY=%.12g ", get_FRACT(world));
fprintf(stderr, "ShiftZ=%.12g\n", get_FRACT(world));
newsize -= 12;
for (j=0; j<NumC+4*NumF; j++) {
fprintf(stderr, " Point[%d]: X=%.12g ", j, get_FRACT(world));
fprintf(stderr, "Y=%.12g ", get_FRACT(world));
fprintf(stderr, "Z=%.12g\n", get_FRACT(world));
newsize -= 12;
}
output_warning(world, "DESC ", "FOR2", newsize);
} else
#endif
if (strcmp(name, "FGRP")==0) { /* Another undocumented chunk */
if (!(fgrp = (FGRP*)malloc(sizeof(FGRP))))
OUT_MEM("FGRP");
i = fgrp->num = get_UWORD(world); /* Number of faces in group */
if (!(fgrp->face = (UWORD*)malloc(i*sizeof(UWORD))))
OUT_MEM("FGRP");
get_name(fgrp->name, 18, world);
for (j=0; j<i; j++)
fgrp->face[j] = get_UWORD(world);
/* Link this new FGRP into list */
fgrp->next = desc->fgrp;
desc->fgrp = fgrp;
} else
if (strcmp(name, "COLR")==0) {
if (!desc->colr) {
if (!(desc->colr = (RGB_st*)malloc(sizeof(RGB_st))))
{ OUT_MEM("COLR"); }
}
stuff_RGB((RGB_st*)&defclst[0], world);
desc->colr->r = defclst[0];
desc->colr->g = defclst[1];
desc->colr->b = defclst[2];
} else
if (strcmp(name, "REFL")==0) {
if (!desc->refl) {
if (!(desc->refl = (RGB_st*)malloc(sizeof(RGB_st))))
{ OUT_MEM("REFL"); }
}
stuff_RGB((RGB_st*)&defrlst[0], world);
desc->refl->r = defrlst[0];
desc->refl->g = defrlst[1];
desc->refl->b = defrlst[2];
} else
if (strcmp(name, "TRAN")==0) {
if (!desc->tran) {
if (!(desc->tran = (RGB_st*)malloc(sizeof(RGB_st))))
{ OUT_MEM("TRAN"); }
}
stuff_RGB((RGB_st*)&deftlst[0], world);
desc->tran->r = deftlst[0];
desc->tran->g = deftlst[1];
desc->tran->b = deftlst[2];
} else
if (strcmp(name, "SPC1")==0) {
if (!desc->spc1) {
if (!(desc->spc1 = (RGB_st*)malloc(sizeof(RGB_st))))
{ OUT_MEM("SPC1"); }
}
stuff_RGB((RGB_st*)&defspc1[0], world);
desc->spc1->r = defspc1[0];
desc->spc1->g = defspc1[1];
desc->spc1->b = defspc1[2];
} else
if (strcmp(name, "CLST")==0) {
i = get_UWORD(world); /* Number of faces */
malloc_arrays(i, desc);
for (j=0; j<i; j++) {
desc->clst[3*j+0] = get_UBYTE(world);
desc->clst[3*j+1] = get_UBYTE(world);
desc->clst[3*j+2] = get_UBYTE(world);
}
} else
if (strcmp(name, "RLST")==0) {
i = get_UWORD(world); /* Number of faces */
malloc_arrays(i, desc);
for (j=0; j<i; j++) {
desc->rlst[3*j+0] = get_UBYTE(world);
desc->rlst[3*j+1] = get_UBYTE(world);
desc->rlst[3*j+2] = get_UBYTE(world);
}
} else
if (strcmp(name, "TLST")==0) {
i = get_UWORD(world); /* Number of faces */
malloc_arrays(i, desc);
for (j=0; j<i; j++) {
desc->tlst[3*j+0] = get_UBYTE(world);
desc->tlst[3*j+1] = get_UBYTE(world);
desc->tlst[3*j+2] = get_UBYTE(world);
}
} else
if (strcmp(name, "TPAR")==0) {
if (!desc->tpar) {
if (!(desc->tpar=(double*)malloc(16*sizeof(double))))
{ OUT_MEM("TPAR"); }
bzero((char*)desc->tpar, 16*sizeof(double));
}
for (i=0; i<16; i++)
desc->tpar[i] = get_FRACT(world);
} else
if (strcmp(name, "SURF")==0) {
if (!desc->surf) {
if (!(desc->surf=(UBYTE*)malloc(5*sizeof(UBYTE))))
{ OUT_MEM("SURF"); }
bzero((char*)desc->surf, 5*sizeof(UBYTE));
}
for (i=0; i<5; i++)
desc->surf[i] = get_BYTE(world);
} else
if (strcmp(name, "MTTR")==0) {
if (!desc->mttr) {
if (!(desc->mttr=(MTTR*)malloc(sizeof(MTTR))))
{ OUT_MEM("MTTR"); }
bzero((char*)desc->mttr, sizeof(MTTR));
}
desc->mttr->type = get_UBYTE(world);
desc->mttr->indx = (get_UBYTE(world)/100.0)+1.0;
} else
if (strcmp(name, "SPEC")==0) {
if (!desc->spec) {
if (!(desc->spec=(UBYTE*)malloc(2*sizeof(UBYTE))))
{ OUT_MEM("SPEC"); }
bzero((char*)desc->spec, 2*sizeof(UBYTE));
}
desc->spec[0] = get_UBYTE(world);
desc->spec[1] = get_UBYTE(world);
} else
if (strcmp(name, "PRP0")==0) {
if (!desc->prp0) {
if (!(desc->prp0=(UBYTE*)malloc(6*sizeof(UBYTE))))
{ OUT_MEM("PRP0"); }
bzero((char*)desc->prp0, 6*sizeof(UBYTE));
}
for (i=0; i<6; i++)
desc->prp0[i] = get_UBYTE(world);
} else
if (strcmp(name, "PRP1")==0) {
if (!desc->prp1) {
if (!(desc->prp1=(UBYTE*)malloc(8*sizeof(UBYTE))))
{ OUT_MEM("PRP1"); }
bzero((char*)desc->prp1, 8*sizeof(UBYTE));
}
for (i=0; i<8; i++)
desc->prp1[i] = get_UBYTE(world);
} else
if (strcmp(name, "INTS")==0) {
if (!desc->ints) {
if (!(desc->ints=(double*)malloc(sizeof(double))))
{ OUT_MEM("INTS"); }
}
*desc->ints = get_FRACT(world);
} else
if (strcmp(name, "INT1")==0) {
if (!desc->int1) desc->int1=(XYZ_st*)malloc(sizeof(XYZ_st));
if (!desc->int1) { OUT_MEM("INT1"); }
stuff_XYZ(desc->int1, world);
} else
if (strcmp(name, "STRY")==0) {
get_name(desc->stry->path, 18, world);
stuff_XYZ(&desc->stry->tran, world);
stuff_XYZ(&desc->stry->rota, world);
stuff_XYZ(&desc->stry->scal, world);
desc->stry->info = get_UWORD(world);
} else {
if (verbose_flag) output_warning(world, "DESC ", name, size);
else {
for (i=size; i--; ) fgetc(world->inp); /* Skip this section */
}
}
if (size&1) { fgetc(world->inp); len--; } /* Skip odd byte */
len -= size;
}
}
/* readistg.c - read an Imagine Stage file
* - written by Glenn M. Lewis - 8/11/92
*/
static void process_OSIZ();
static void process_POSN();
static void process_ALGN();
static void process_PALN();
static void process_TALN();
static void process_PTH2();
static void process_GLB2();
static void process_AXIS();
static void process_LITE();
static void process_FILE();
static void process_SOBJ();
WORLD *read_ISTG(file)
FILE *file;
{
register ULONG i, len, size;
WORLD *world;
char name[5];
if (!file) return(0L); /* File not open */
if (!(world = (WORLD*)malloc(sizeof(WORLD)))) { OUT_MEM("WORLD"); }
bzero((char*)world, sizeof(WORLD));
world->inp = file;
if (!already_read_header) {
/* Parse the IFF ISTG file */
get_name(name, 4, world);
if (strcmp(name, "FORM") != 0) {
fprintf(stderr, "ERROR: Input is not an IFF file.\n"); exit(-1); }
if (!(len = get_ULONG(world))) {
fprintf(stderr, "ERROR: Bad FORM length in IFF file.\n"); exit(-1); }
get_name(name, 4, world);
if (strcmp(name, "ISTG") != 0) {
fprintf(stderr, "ERROR: IFF file is not a ISTG file.\n"); exit(-1); }
} else {
len = (header_storage[4]<<24) | (header_storage[5]<<16) |
(header_storage[6]<< 8) | (header_storage[7] );
already_read_header = 0;
}
len -= 4;
/* Allocate the ISTG structure */
if (!(world->istg = (ISTG*)malloc(sizeof(ISTG)))) { OUT_MEM("ISTG"); }
bzero((char*)world->istg, sizeof(ISTG));
/* Here is the main loop: */
while (len>0) {
get_name(name, 4, world);
size = get_ULONG(world);
len -= 8;
if (strcmp(name, "MAXF")==0) world->istg->maxf = get_UWORD(world);
else
if (strcmp(name, "SOBJ")==0) process_SOBJ(size, world);
else {
if (verbose_flag) output_warning(world, "ISTG ", name, size);
else {
for (i=size; i--; ) fgetc(world->inp); /* Skip this section */
}
}
if (size&1) { fgetc(world->inp); len--; } /* Skip odd byte */
len -= size;
}
/* All done. */
return(world);
}
SOBJ *add_SOBJ(istg) /* to tail of ISTG's SOBJ list */
ISTG *istg;
{
SOBJ *new;
if (!(new = (SOBJ*)malloc(sizeof(SOBJ)))) OUT_MEM("SOBJ");
bzero((char*)new, sizeof(SOBJ));
if (!istg->head) {
istg->head = istg->tail = new;
return(new);
}
/* Add this SOBJ to the tail */
new->prev = istg->tail;
istg->tail->next = new;
istg->tail = new;
return(new);
}
static void process_SOBJ(len, world)
register ULONG len;
WORLD *world;
{
register ULONG i, size;
char name[5];
SOBJ *sobj;
if (verbose_flag>1) fprintf(stderr, "SOBJ chunk.\n");
/* Add another SOBJ to the current ISTG list */
sobj = add_SOBJ(world->istg);
while (len>0) {
get_name(name, 4, world);
size = get_ULONG(world);
len -= 8;
if (verbose_flag>1) fprintf(stderr, "%s chunk.\n", name);
if (strcmp(name, "NAME")==0) { get_name(sobj->name, (int)size, world);
} else if (strcmp(name, "STGF")==0) { sobj->stgf = get_UWORD(world);
} else if (strcmp(name, "OSIZ")==0) { process_OSIZ(size, sobj, world);
} else if (strcmp(name, "POSN")==0) { process_POSN(size, sobj, world);
} else if (strcmp(name, "ALGN")==0) { process_ALGN(size, sobj, world);
} else if (strcmp(name, "PALN")==0) { process_PALN(size, sobj, world);
} else if (strcmp(name, "TALN")==0) { process_TALN(size, sobj, world);
} else if (strcmp(name, "PTH2")==0) { process_PTH2(size, sobj, world);
} else if (strcmp(name, "GLB2")==0) { process_GLB2(size, sobj, world);
} else if (strcmp(name, "AXIS")==0) { process_AXIS(size, sobj, world);
} else if (strcmp(name, "LITE")==0) { process_LITE(size, sobj, world);
} else if (strcmp(name, "FILE")==0) { process_FILE(size, sobj, world);
} else {
if (verbose_flag) output_warning(world, "SOBJ ", name, size);
else {
for (i=size; i--; ) fgetc(world->inp); /* Skip this section */
}
}
if (size&1) { fgetc(world->inp); len--; } /* Skip odd byte */
len -= size;
}
}
static void process_OSIZ(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register OSIZ *osiz;
if (!(osiz = (OSIZ*)malloc(sizeof(OSIZ)))) OUT_MEM("OSIZ");
bzero((char*)osiz, sizeof(OSIZ));
osiz->flags = get_UWORD(world);
osiz->start = get_UWORD(world);
osiz->stop = get_UWORD(world);
stuff_XYZ(&osiz->size, world);
insert_into_sorted_list((PALN**)&sobj->osiz, (PALN*)osiz);
}
static void process_POSN(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register POSN *posn;
if (!(posn = (POSN*)malloc(sizeof(POSN)))) OUT_MEM("POSN");
bzero((char*)posn, sizeof(POSN));
posn->flags = get_UWORD(world);
posn->start = get_UWORD(world);
posn->stop = get_UWORD(world);
stuff_XYZ(&posn->posn, world);
insert_into_sorted_list((PALN**)&sobj->posn, (PALN*)posn);
}
static void process_ALGN(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register ALGN *algn;
if (!(algn = (ALGN*)malloc(sizeof(ALGN)))) OUT_MEM("ALGN");
bzero((char*)algn, sizeof(ALGN));
algn->flags = get_UWORD(world);
algn->start = get_UWORD(world);
algn->stop = get_UWORD(world);
stuff_XYZ(&algn->algn, world);
insert_into_sorted_list((PALN**)&sobj->algn, (PALN*)algn);
}
static void process_PALN(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register PALN *paln;
if (!(paln = (PALN*)malloc(sizeof(PALN)))) OUT_MEM("PALN");
bzero((char*)paln, sizeof(PALN));
paln->flags = get_UWORD(world);
paln->start = get_UWORD(world);
paln->stop = get_UWORD(world);
insert_into_sorted_list(&sobj->paln, paln);
}
static void process_TALN(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register TALN *taln;
if (!(taln = (TALN*)malloc(sizeof(TALN)))) OUT_MEM("TALN");
bzero((char*)taln, sizeof(TALN));
taln->flags = get_UWORD(world);
taln->start = get_UWORD(world);
taln->stop = get_UWORD(world);
taln->initial_y = get_FRACT(world);
taln->final_y = get_FRACT(world);
size -= 15L;
/* BCPL string... byte followed by string, followed by zero */
get_UBYTE(world);
if (size)
get_name(taln->trackobj, (int)size, world);
insert_into_sorted_list((PALN**)&sobj->taln, (PALN*)taln);
}
static void process_PTH2(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register PTH2 *pth2;
if (!(pth2 = (PTH2*)malloc(sizeof(PTH2)))) OUT_MEM("PTH2");
bzero((char*)pth2, sizeof(PTH2));
pth2->flags = get_UWORD(world);
pth2->start = get_UWORD(world);
pth2->stop = get_UWORD(world);
pth2->acceleration_frames = get_ULONG(world);
pth2->start_speed = get_FRACT(world);
pth2->deacceleration_frames = get_ULONG(world);
pth2->end_speed = get_FRACT(world);
size -= 23L;
/* BCPL string... byte followed by string, followed by zero */
get_UBYTE(world);
if (size)
get_name(pth2->path, (int)size, world);
insert_into_sorted_list((PALN**)&sobj->pth2, (PALN*)pth2);
}
static void process_GLB2(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register GLB2 *glb2;
if (!(glb2 = (GLB2*)malloc(sizeof(GLB2)))) OUT_MEM("GLB2");
bzero((char*)glb2, sizeof(GLB2));
glb2->flags = get_UWORD(world);
glb2->start = get_UWORD(world);
glb2->stop = get_UWORD(world);
glb2->sky_blending = get_ULONG(world);
glb2->starfield = get_FRACT(world);
glb2->transition = get_ULONG(world);
/* The following are FRACTional colors */
stuff_XYZ(&glb2->ambient, world);
stuff_XYZ(&glb2->horizon, world);
stuff_XYZ(&glb2->zenith1, world);
stuff_XYZ(&glb2->zenith2, world);
stuff_XYZ(&glb2->fog_color, world);
glb2->fog_bottom = get_FRACT(world);
glb2->fog_top = get_FRACT(world);
glb2->fog_length = get_FRACT(world);
glb2->brush_seq = get_ULONG(world);
glb2->backdrop_seq = get_ULONG(world);
get_name(glb2->backdrop, 256, world); /* Fixed size */
size -= 355L;
/* BCPL string... byte followed by string, followed by zero */
get_UBYTE(world);
if (size)
get_name(glb2->globalbrush, (int)size, world); /* Var. size */
insert_into_sorted_list((PALN**)&sobj->glb2, (PALN*)glb2);
}
static void process_AXIS(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register SAXIS *axis;
if (!(axis = (SAXIS*)malloc(sizeof(SAXIS)))) OUT_MEM("SAXIS");
bzero((char*)axis, sizeof(SAXIS));
axis->flags = get_UWORD(world);
axis->start = get_UWORD(world);
axis->stop = get_UWORD(world);
insert_into_sorted_list((PALN**)&sobj->axis, (PALN*)axis);
}
static void process_LITE(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register LITE *lite;
if (!(lite = (LITE*)malloc(sizeof(LITE)))) OUT_MEM("LITE");
bzero((char*)lite, sizeof(LITE));
lite->flags = get_UWORD(world);
lite->start = get_UWORD(world);
lite->stop = get_UWORD(world);
/* The following is a FRACTional color */
stuff_XYZ(&lite->color, world);
lite->transition = get_ULONG(world);
insert_into_sorted_list((PALN**)&sobj->lite, (PALN*)lite);
}
static void process_FILE(size, sobj, world)
ULONG size;
SOBJ *sobj;
WORLD *world;
{
register SFILE *file;
if (!(file = (SFILE*)malloc(sizeof(SFILE)))) OUT_MEM("SFILE");
bzero((char*)file, sizeof(SFILE));
file->flags = get_UWORD(world);
file->start = get_UWORD(world);
file->stop = get_UWORD(world);
file->cycles_to_perform = get_FRACT(world);
file->initial_cycle_phase = get_FRACT(world);
file->transition = get_ULONG(world);
size -= 19L;
/* BCPL string... byte followed by string, followed by zero */
get_UBYTE(world);
if (size)
get_name(file->object_description, (int)size, world);
insert_into_sorted_list((PALN**)&sobj->file, (PALN*)file);
}
/* We use "PALN" here, even though this routine inserts all SOBJ sub-types
* into their proper list, because all be need is "START" and "STOP"
* information, and "PALN" is the minimal structure that provides this
*/
void insert_into_sorted_list(ppaln, paln)
PALN **ppaln, *paln;
{
register PALN *p;
if (!*ppaln) { *ppaln = paln; return; } /* First in list */
/* Now search through the list and insert in the proper place */
for (p= *ppaln; p; p=p->next) {
if (paln->start == p->start ||
paln->start == p->stop ||
paln->stop == p->start ||
paln->stop == p->stop) {
fprintf(stderr, "WARNING!!! start and stop times collide! (%u-%u) vs (%u-%u)\n",
paln->start, paln->stop, p->start, p->stop);
}
if (paln->stop < p->start) { /* Insert the item before this one */
paln->prev = p->prev;
paln->next = p;
p->prev = paln;
if (p == *ppaln) { *ppaln = paln; } /* New head of list */
return;
}
if (!p->next) { /* Insert after this item */
p->next = paln;
paln->prev = p;
return;
}
}
/* Never will reach here! */
}
/* Find the last existing key frame that would be applicable for "frame" */
void delete_unused_frames(orig, frame)
PALN **orig;
{
register PALN *p;
PALN *p2;
for (p= *orig; p; ) {
if (frame>=p->start && frame<=p->stop) return; /* It falls within this keyframe */
if (frame>=p->stop && (!p->next || (p->next && frame<p->next->start))) return; /* This is the one! */
/* Otherwise, delete it */
if (p->next) p->next->prev = p->prev;
if (p->prev) p->prev->next = p->next;
if (p== *orig) *orig = p->next;
p2 = p->next;
free(p);
p = p2;
}
}
static void mtrx_ident(mtrx)
register MTRX *mtrx;
{
mtrx->tran.x = mtrx->tran.y = mtrx->tran.z = 0.0;
mtrx->scal.x = mtrx->scal.y = mtrx->scal.z = 1.0;
mtrx->rota1.y = mtrx->rota1.z = 0.0;
mtrx->rota2.x = mtrx->rota2.z = 0.0;
mtrx->rota3.x = mtrx->rota3.y = 0.0;
mtrx->rota1.x = mtrx->rota2.y = mtrx->rota3.z = 1.0;
}
static void mmultiply(s, d)
register double *s;
register double *d;
{
register int j;
double tmp[9];
tmp[0] = s[0]*d[0] + s[1]*d[3] + s[2]*d[6];
tmp[1] = s[0]*d[1] + s[1]*d[4] + s[2]*d[7];
tmp[2] = s[0]*d[2] + s[1]*d[5] + s[2]*d[8];
tmp[3] = s[3]*d[0] + s[4]*d[3] + s[5]*d[6];
tmp[4] = s[3]*d[1] + s[4]*d[4] + s[5]*d[7];
tmp[5] = s[3]*d[2] + s[4]*d[5] + s[5]*d[8];
tmp[6] = s[6]*d[0] + s[7]*d[3] + s[8]*d[6];
tmp[7] = s[6]*d[1] + s[7]*d[4] + s[8]*d[7];
tmp[8] = s[6]*d[2] + s[7]*d[5] + s[8]*d[8];
for (j = 9; j--; ) d[j] = tmp[j];
}
/*
Matrix Inversion
by Richard Carling
from "Graphics Gems", Academic Press, 1990
tweaked heavily by Glenn M. Lewis to not require "GraphicsGems.h" and
to work only on 3x3 matrices
*/
#define SMALL_NUMBER 1.e-8
#define det2x2(a,b,c,d) ((a)*(d)-(b)*(c))
#define det3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3) \
((a1) * det2x2((b2), (b3), (c2), (c3)) \
-(b1) * det2x2((a2), (a3), (c2), (c3)) \
+(c1) * det2x2((a2), (a3), (b2), (b3)))
/*
* inverse(original_matrix, inverse_matrix)
*
* calculate the inverse of a 3x3 matrix
*
* -1
* A = ___1__ adjoint A
* det A
*/
void inverse(in, out)
register double *in, *out;
{
int i;
double det;
void adjoint();
/* calculate the adjoint matrix */
adjoint(in, out);
/* calculate the 3x3 determinent
* if the determinent is zero,
* then the inverse matrix is not unique.
*/
det = det3x3(
in[0], in[1], in[2],
in[3], in[4], in[5],
in[6], in[7], in[8]
);
if (fabs(det) < SMALL_NUMBER) return; /* non-singular matrix */
/* scale the adjoint matrix to get the inverse */
det = 1.0/det;
for (i=0; i<9; i++) out[i] *= det;
}
/*
* adjoint(original_matrix, inverse_matrix)
*
* calculate the adjoint of a 4x4 matrix
*
* Let a denote the minor determinant of matrix A obtained by
* ij
*
* deleting the ith row and jth column from A.
*
* i+j
* Let b = (-1) a
* ij ji
*
* The matrix B = (b ) is the adjoint of A
* ij
*/
void adjoint(in, out)
register double *in, *out;
{
/* row column labeling reversed since we transpose rows & columns */
out[0] = det2x2(in[4], in[7], in[5], in[8]);
out[4] = - det2x2(in[3], in[6], in[5], in[8]);
out[6] = det2x2(in[3], in[6], in[4], in[7]);
out[1] = - det2x2(in[1], in[7], in[2], in[8]);
out[4] = det2x2(in[0], in[6], in[2], in[8]);
out[7] = - det2x2(in[0], in[6], in[1], in[7]);
out[2] = det2x2(in[1], in[4], in[2], in[5]);
out[5] = - det2x2(in[0], in[3], in[2], in[5]);
out[8] = det2x2(in[0], in[3], in[1], in[4]);
}
OBJECT *load_staging_object(filename, mtrx)
char *filename;
MTRX *mtrx;
{
WORLD *new;
FILE *newinp;
register OBJECT *p;
/* Now, load in the external object */
TRY_EXTR_AGAIN:
if (!(newinp=fopen(filename, "r"))) {
fprintf(stderr, "Can't load in EXTR object: '%s'.\n",
filename);
fprintf(stderr, "Enter filneame (or CR to abort): "); fflush(stderr);
fgets(filename, 512, stdin);
if (!filename[0] || filename[0]=='\n') return(0L);
goto TRY_EXTR_AGAIN;
}
new = read_World(newinp);
fclose(newinp);
/* scale, rotate, and translate new object hierarchy */
/* First, take a look at the root object's size an orientation,
* and scale all subobjects appropriately
*/
p = new->object;
if (p) {
if (p->desc->size) {
if (p->desc->size->x != 0.0)
mtrx->scal.x /= p->desc->size->x;
if (p->desc->size->y != 0.0)
mtrx->scal.y /= p->desc->size->y;
if (p->desc->size->z != 0.0)
mtrx->scal.z /= p->desc->size->z;
}
if (p->desc->axis) {
/* inverse(&p->desc->axis->xaxi.x, &newmtrx.rota1.x); */
/* mmultiply(&newmtrx.rota1.x, &mtrx->rota1.x); */
mmultiply(&p->desc->axis->xaxi.x, &mtrx->rota1.x);
}
}
for (p=new->object; p; p=p->next)
move_extr(p, mtrx);
p = new->object;
free((char*)new);
return(p);
}
void load_staging_frame_objects(world, frame)
WORLD *world;
int frame;
{
register SOBJ *sobj;
MTRX mtrx, tmpmtrx;
OBJECT *obj;
double angle, sin(), cos();
if (!world) return;
if (!world->istg) return;
if (frame<1 || frame>world->istg->maxf) {
fprintf(stderr, "ERROR: desired frame (%d) is larger than MAXF (%d)\n",
frame, world->istg->maxf);
return;
}
/* Search through all of the "SOBJ" chunks and load in objects that
* are active during the specified frame
*/
for (sobj=world->istg->head; sobj; sobj=sobj->next) {
/* Easiest method is to simply delete all the information in the SOBJ
* sub-chunks that does not fall within the specified frame time.
*/
delete_unused_frames((PALN**)&sobj->osiz, frame); /* Size */
delete_unused_frames((PALN**)&sobj->posn, frame); /* Position */
delete_unused_frames((PALN**)&sobj->algn, frame); /* Alignment */
delete_unused_frames((PALN**)&sobj->paln, frame); /* Path Alignment */
delete_unused_frames((PALN**)&sobj->taln, frame); /* Track Alignment */
delete_unused_frames((PALN**)&sobj->pth2, frame); /* Follow Path */
delete_unused_frames((PALN**)&sobj->glb2, frame); /* Globals */
delete_unused_frames((PALN**)&sobj->axis, frame); /* Stagefile AXIS */
delete_unused_frames((PALN**)&sobj->lite, frame); /* Light */
delete_unused_frames((PALN**)&sobj->file, frame); /* Stage file */
/* Now, we have a list of SOBJ chunks with information for this frame */
if (!sobj->file) continue; /* No filename information */
/* Initialize transformation matrix structure */
mtrx_ident(&mtrx);
/* Now modify matrix based upon requested transformations */
if (sobj->posn) { bcopy((char*)&sobj->posn->posn.x, (char*)&mtrx.tran.x, sizeof(XYZ_st)); }
if (sobj->osiz) { bcopy((char*)&sobj->osiz->size.x, (char*)&mtrx.scal.x, sizeof(XYZ_st)); }
if (sobj->algn) {
/* First Z rotation, then X, then Y */
if (sobj->algn->algn.z != 0.0) {
angle = sobj->algn->algn.z * PI / 180.0;
mtrx_ident(&tmpmtrx); /* Initialize it */
tmpmtrx.rota1.x = tmpmtrx.rota2.y = cos(angle);
tmpmtrx.rota2.x = sin(angle);
tmpmtrx.rota1.y = -tmpmtrx.rota2.x;
mmultiply(&tmpmtrx.rota1.x, &mtrx.rota1.x);
} else if (sobj->algn->algn.x != 0.0) {
angle = sobj->algn->algn.x * PI / 180.0;
mtrx_ident(&tmpmtrx); /* Initialize it */
tmpmtrx.rota2.y = tmpmtrx.rota3.z = cos(angle);
tmpmtrx.rota3.y = sin(angle);
tmpmtrx.rota2.z = -tmpmtrx.rota3.y;
mmultiply(&tmpmtrx.rota1.x, &mtrx.rota1.x);
} else if (sobj->algn->algn.y != 0.0) {
angle = sobj->algn->algn.y * PI / 180.0;
mtrx_ident(&tmpmtrx); /* Initialize it */
tmpmtrx.rota1.x = tmpmtrx.rota3.z = cos(angle);
tmpmtrx.rota1.z = sin(angle);
tmpmtrx.rota3.x = -tmpmtrx.rota1.z;
mmultiply(&tmpmtrx.rota1.x, &mtrx.rota1.x);
}
}
/* Okeydokey... let's load in that object! */
obj = load_staging_object(sobj->file->object_description, &mtrx);
if (world->curobj) {
world->curobj->next = obj;
obj->parent = world->curobj->parent;
while (obj->next) {
obj->next->parent = obj->parent;
obj = obj->next;
world->curobj = obj;
}
} else {
world->object = obj;
obj->parent = 0;
}
world->curobj = obj;
}
}